// 拍照相关逻辑
var file_path = '_doc/PhotoFiler/'; // 使用应用私有目录
var fixed; // 文件名常量
var fixedFilename; // 文件名常量

// 获取当前分组目录路径
function getCurrentGroupPath() {
    console.log('获取当前分组路径');
    
    // 从本地存储获取当前分组
    let currentGroup = '房屋拍照'; // 默认分组
    
    if (typeof plus !== 'undefined' && plus.storage) {
        try {
            const savedGroup = plus.storage.getItem('current_group');
            if (savedGroup) {
                currentGroup = savedGroup;
                console.log('从本地存储获取分组:', currentGroup);
            }
        } catch (error) {
            console.error('读取本地存储失败:', error);
        }
    }
    
    // 构建分组目录路径
    const groupPath = '_doc/PhotoFiler/' + currentGroup + '/';
    console.log('分组目录路径:', groupPath);
    return groupPath;
}

// 确保应用目录存在
function ensureAppDirectory() {
    return new Promise((resolve, reject) => {
        const groupPath = getCurrentGroupPath();
        console.log('确保分组目录存在:', groupPath);
        
        plus.io.resolveLocalFileSystemURL(groupPath, (entry) => {
            console.log('分组目录已存在:', entry);
            resolve(entry);
        }, (error) => {
            console.log('分组目录不存在，创建目录:', error.message);
            // 创建分组目录
            createGroupDirectory(groupPath).then(resolve).catch(reject);
        });
    });
}

// 创建分组目录
function createGroupDirectory(groupPath) {
    console.log('创建分组目录:', groupPath);
    return new Promise((resolve, reject) => {
        // 先确保PhotoFiler目录存在
        plus.io.resolveLocalFileSystemURL('_doc/', (parentEntry) => {
            parentEntry.getDirectory('PhotoFiler', { create: true }, (photoFilerEntry) => {
                console.log('PhotoFiler目录获取/创建成功:', photoFilerEntry);
                
                // 从路径中提取分组名称
                const pathParts = groupPath.split('/');
                const groupName = pathParts[pathParts.length - 2];
                console.log('分组名称:', groupName);
                
                // 在PhotoFiler目录下创建分组目录
                photoFilerEntry.getDirectory(groupName, { create: true }, (groupEntry) => {
                    console.log('分组目录创建成功:', groupEntry);
                    resolve(groupEntry);
                }, (error) => {
                    console.error('分组目录创建失败:', error);
                    reject(error);
                });
            }, (error) => {
                console.error('PhotoFiler目录创建失败:', error);
                reject(error);
            });
        }, (error) => {
            console.error('父目录获取失败:', error);
            reject(error);
        });
    });
}

// 拍照
function captureImage() {
    console.log("=== 开始拍照 ===");
    
    // 获取当前分组路径
    const groupPath = getCurrentGroupPath();
    console.log("当前分组路径:", groupPath);
    
    // 先确保目录存在
    ensureAppDirectory().then(() => {
        var time_info = new Date().getTime().toString();
        var res = cmr.supportedImageResolutions[0];
        var fmt = cmr.supportedImageFormats[0];
        console.log("Resolution: " + res + ", Format: " + fmt);
        console.log("时间戳:", time_info);
        
        // 生成目标文件名
        var targetFilename = time_info + ".jpg";
        var targetPath = groupPath + targetFilename;
        console.log("目标文件路径:", targetPath);
        console.log("目标文件名:", targetFilename);
        
        cmr.captureImage(function(path) {
            console.log("=== 拍照成功回调 ===");
            console.log("返回的图片路径:", path);
            console.log("返回路径类型:", typeof path);
            
            plus.nativeUI.toast("拍摄成功！");
            
            // 直接显示预览（因为已经保存到目标位置了）
            showPreview(path);
            
            // 通知相册刷新
            if (typeof refreshGallery === 'function') {
                setTimeout(() => {
                    console.log("刷新相册");
                    refreshGallery();
                }, 1000);
            }
            
            // 更新统计信息
            if (typeof gallery !== 'undefined' && gallery.updateHeaderStats) {
                setTimeout(() => {
                    console.log("更新顶部统计信息");
                    gallery.updateHeaderStats();
                }, 1000);
            }
            
        }, function(error) {
            console.error("=== 拍照失败回调 ===");
            console.error("错误信息:", error);
            alert("拍照取消");
        }, {
            resolution: res,
            format: fmt,
            filename: targetPath  // 直接指定保存路径
        });
    }).catch((error) => {
        console.error('目录创建失败:', error);
        plus.nativeUI.toast('目录创建失败，无法拍照');
    });
}

// 显示图片预览
function showPreview(imagePath) {
    console.log("=== 开始显示预览 ===");
    console.log("图片路径:", imagePath);
    console.log("图片路径类型:", typeof imagePath);
    
    // 检查DOM元素是否存在
    var captureBtn = document.getElementById('capture-btn');
    var retakeBtn = document.getElementById('retake-btn');
    var saveBtn = document.getElementById('save-btn');
    var previewContainer = document.getElementById('preview-container');
    var previewPlaceholder = document.getElementById('preview-placeholder');
    var previewImage = document.getElementById('preview-image');
    var previewImageWrapper = document.querySelector('.preview-image-wrapper');
    
    console.log("拍照按钮元素:", captureBtn);
    console.log("预览容器元素:", previewContainer);
    console.log("预览图片元素:", previewImage);
    
    if (!captureBtn || !previewContainer || !previewImage) {
        console.error("DOM元素未找到！");
        plus.nativeUI.toast("预览组件加载失败");
        return;
    }
    
    // 隐藏拍照按钮，显示重拍按钮（因为已经自动保存了）
    console.log("隐藏拍照按钮，显示重拍按钮");
    captureBtn.style.display = 'none';
    if (retakeBtn) retakeBtn.style.display = 'flex';
    // 不显示保存按钮，因为已经自动保存了
    if (saveBtn) saveBtn.style.display = 'none';
    
    // 隐藏占位符，显示图片预览
    if (previewPlaceholder) previewPlaceholder.style.display = 'none';
    if (previewImageWrapper) previewImageWrapper.style.display = 'flex';
    
    // 使用resolveLocalFileSystemURL获取文件entry，然后使用toLocalURL()
    console.log("使用resolveLocalFileSystemURL获取文件entry...");
    plus.io.resolveLocalFileSystemURL(imagePath, function(entry) {
        console.log("文件entry获取成功:", entry);
        console.log("entry类型:", entry.isFile ? "FileEntry" : "DirectoryEntry");
        
        // 使用toLocalURL()获取本地URL
        var localUrl = entry.toLocalURL();
        console.log("toLocalURL()结果:", localUrl);
        
        // 设置图片源
        console.log("设置图片源:", localUrl);
        previewImage.src = localUrl;
        
    }, function(error) {
        console.error("resolveLocalFileSystemURL失败:", error);
        plus.nativeUI.toast("文件路径解析失败: " + error.message);
    });
    
    // 添加图片加载事件监听
    previewImage.onload = function() {
        console.log("图片加载成功！");
        console.log("图片尺寸:", this.naturalWidth + "x" + this.naturalHeight);
        console.log("显示尺寸:", this.offsetWidth + "x" + this.offsetHeight);
    };
    
    previewImage.onerror = function() {
        console.error("图片加载失败！");
        console.error("当前src:", this.src);
        plus.nativeUI.toast("图片加载失败，请检查文件路径");
    };
    
    // 检查显示状态
    setTimeout(function() {
        console.log("预览容器显示状态:", previewContainer.style.display);
        console.log("预览容器可见性:", previewContainer.offsetWidth + "x" + previewContainer.offsetHeight);
        console.log("图片元素可见性:", previewImage.offsetWidth + "x" + previewImage.offsetHeight);
    }, 100);
    
    console.log("=== 预览显示完成 ===");
}

// 重新拍照
function retakePhoto() {
    // 显示占位符，隐藏图片预览
    var previewPlaceholder = document.getElementById('preview-placeholder');
    var previewImageWrapper = document.querySelector('.preview-image-wrapper');
    if (previewPlaceholder) previewPlaceholder.style.display = 'flex';
    if (previewImageWrapper) previewImageWrapper.style.display = 'none';
    
    // 显示拍照按钮，隐藏重拍和保存按钮
    var captureBtn = document.getElementById('capture-btn');
    var retakeBtn = document.getElementById('retake-btn');
    var saveBtn = document.getElementById('save-btn');
    
    if (captureBtn) captureBtn.style.display = 'flex';
    if (retakeBtn) retakeBtn.style.display = 'none';
    if (saveBtn) saveBtn.style.display = 'none';
    
    // 清除保存相关的变量
    fixed = null;
    fixedFilename = null;
    
    // 清除预览图片（先移除事件监听器避免触发错误）
    var previewImage = document.getElementById('preview-image');
    if (previewImage) {
        // 移除事件监听器，避免清除src时触发onerror
        previewImage.onerror = null;
        previewImage.onload = null;
        previewImage.src = '';
    }
}

// 保存照片
function savePhoto() {
    console.log("=== 保存照片 ===");
    console.log("当前fixed路径:", fixed);
    console.log("当前fixed文件名:", fixedFilename);
    
    if (fixed && fixedFilename) {
        // 确保目录存在
        ensureAppDirectory().then(() => {
            console.log("目录确认存在，开始移动照片");
            
            // 移动照片到目标位置
            movePhotoToTarget().then(() => {
                console.log("照片移动成功");
                plus.nativeUI.toast("照片已保存到应用相册");
                
                // 延迟一下再重置界面，确保成功提示显示完整
                setTimeout(function() {
                    retakePhoto();
                    
                    // 通知相册刷新
                    if (typeof refreshGallery === 'function') {
                        console.log("准备通知相册刷新");
                        
                        // 增加延迟时间，确保文件系统同步
                        setTimeout(() => {
                            console.log("开始刷新相册");
                            refreshGallery();
                        }, 2000); // 增加到2秒
                        
                        // 再次延迟刷新，以防第一次刷新失败
                        setTimeout(() => {
                            console.log("第二次刷新相册");
                            refreshGallery();
                        }, 4000); // 4秒后再次刷新
                    } else {
                        console.error("refreshGallery函数不存在");
                    }
                    
                    // 立即更新顶部统计信息
                    if (typeof gallery !== 'undefined' && gallery.updateHeaderStats) {
                        setTimeout(() => {
                            console.log("更新顶部统计信息");
                            gallery.updateHeaderStats();
                        }, 1000); // 1秒后更新统计
                    }
                }, 500);
            }).catch((error) => {
                console.error('照片移动失败:', error);
                plus.nativeUI.toast("保存失败: " + error.message);
            });
        }).catch((error) => {
            console.error('目录创建失败:', error);
            plus.nativeUI.toast("保存失败: " + error.message);
        });
    } else {
        console.error("保存失败，fixed路径或文件名为空");
        plus.nativeUI.toast("保存失败，请重新拍照");
    }
}

// 移动照片到目标位置
function movePhotoToTarget() {
    console.log("=== 移动照片到目标位置 ===");
    
    return new Promise((resolve, reject) => {
        // 获取当前分组路径
        const groupPath = getCurrentGroupPath();
        const targetPath = groupPath + fixedFilename;
        console.log("目标路径:", targetPath);
        console.log("目标文件名:", fixedFilename);
        
        // 先获取临时照片的entry
        plus.io.resolveLocalFileSystemURL('_doc/', (docEntry) => {
            console.log("doc目录获取成功");
            
            // 查找临时照片文件
            findTempPhotoFile(docEntry).then((tempFileEntry) => {
                console.log("找到临时照片文件:", tempFileEntry.name);
                console.log("临时文件路径:", tempFileEntry.fullPath);
                
                // 获取目标目录entry
                plus.io.resolveLocalFileSystemURL(groupPath, (targetDirEntry) => {
                    console.log("目标目录获取成功:", targetDirEntry.name);
                    console.log("目标目录路径:", targetDirEntry.fullPath);
                    
                    // 检查目标文件是否已存在
                    targetDirEntry.getFile(fixedFilename, {}, (existingFile) => {
                        console.log("目标文件已存在，先删除:", existingFile.name);
                        existingFile.remove(() => {
                            console.log("已删除现有文件，开始移动");
                            performMove(tempFileEntry, targetDirEntry, resolve, reject);
                        }, (error) => {
                            console.error("删除现有文件失败:", error);
                            // 即使删除失败也继续移动
                            performMove(tempFileEntry, targetDirEntry, resolve, reject);
                        });
                    }, (error) => {
                        console.log("目标文件不存在，直接移动");
                        performMove(tempFileEntry, targetDirEntry, resolve, reject);
                    });
                    
                }, (error) => {
                    console.error("目标目录获取失败:", error);
                    console.error("尝试的路径:", groupPath);
                    reject(new Error("目标目录获取失败: " + error.message));
                });
                
            }).catch((error) => {
                console.error("查找临时照片失败:", error);
                reject(error);
            });
            
        }, (error) => {
            console.error("doc目录获取失败:", error);
            reject(new Error("doc目录获取失败: " + error.message));
        });
    });
}

// 执行文件移动
function performMove(tempFileEntry, targetDirEntry, resolve, reject) {
    console.log("执行文件移动操作");
    console.log("源文件:", tempFileEntry.name);
    console.log("目标目录:", targetDirEntry.name);
    console.log("目标文件名:", fixedFilename);
    
    tempFileEntry.moveTo(targetDirEntry, fixedFilename, (movedFileEntry) => {
        console.log("照片移动成功:", movedFileEntry.name);
        console.log("移动后文件路径:", movedFileEntry.fullPath);
        resolve(movedFileEntry);
    }, (error) => {
        console.error("照片移动失败:", error);
        console.error("错误代码:", error.code);
        console.error("错误消息:", error.message);
        reject(new Error("照片移动失败: " + error.message));
    });
}

// 查找临时照片文件
function findTempPhotoFile(docEntry) {
    console.log("=== 查找临时照片文件 ===");
    
    return new Promise((resolve, reject) => {
        const reader = docEntry.createReader();
        reader.readEntries((entries) => {
            console.log("doc目录内容:", entries.length, "个条目");
            
            // 过滤出jpg文件
            const jpgFiles = entries.filter(entry => entry.isFile && entry.name.toLowerCase().endsWith('.jpg'));
            console.log("找到jpg文件数量:", jpgFiles.length);
            
            if (jpgFiles.length === 0) {
                reject(new Error("未找到任何jpg文件"));
                return;
            }
            
            // 从文件名中提取时间戳，找到最新的文件
            let latestFile = null;
            let latestTimestamp = 0;
            
            jpgFiles.forEach((entry) => {
                console.log("处理jpg文件:", entry.name);
                
                // 从文件名中提取时间戳（文件名格式：1751714335783.jpg）
                const filename = entry.name;
                const timestampStr = filename.replace('.jpg', '');
                const timestamp = parseInt(timestampStr);
                
                console.log("文件名:", filename, "提取的时间戳:", timestamp);
                
                if (!isNaN(timestamp) && timestamp > latestTimestamp) {
                    latestTimestamp = timestamp;
                    latestFile = entry;
                    console.log("更新最新文件:", entry.name, "时间戳:", timestamp);
                }
            });
            
            if (latestFile) {
                console.log("找到最新的临时照片:", latestFile.name, "时间戳:", latestTimestamp);
                resolve(latestFile);
            } else {
                console.error("未找到有效的临时照片文件");
                reject(new Error("未找到有效的临时照片文件"));
            }
        }, (error) => {
            console.error("读取目录失败:", error);
            reject(new Error("读取目录失败: " + error.message));
        });
    });
}

// 直接移动照片到目标位置（避免重复保存）
function movePhotoToTargetDirectly(tempPath, targetPath, targetFilename) {
    console.log("=== 直接移动照片到目标位置 ===");
    console.log("临时文件路径:", tempPath);
    console.log("目标路径:", targetPath);
    console.log("目标文件名:", targetFilename);
    
    return new Promise((resolve, reject) => {
        // 获取当前分组路径
        const groupPath = getCurrentGroupPath();
        
        // 先获取临时照片的entry
        plus.io.resolveLocalFileSystemURL(tempPath, (tempFileEntry) => {
            console.log("临时文件entry获取成功:", tempFileEntry.name);
            
            // 获取目标目录entry
            plus.io.resolveLocalFileSystemURL(groupPath, (targetDirEntry) => {
                console.log("目标目录获取成功:", targetDirEntry.name);
                
                // 检查目标文件是否已存在
                targetDirEntry.getFile(targetFilename, {}, (existingFile) => {
                    console.log("目标文件已存在，先删除:", existingFile.name);
                    existingFile.remove(() => {
                        console.log("已删除现有文件，开始移动");
                        performMoveDirectly(tempFileEntry, targetDirEntry, targetFilename, resolve, reject);
                    }, (error) => {
                        console.error("删除现有文件失败:", error);
                        // 即使删除失败也继续移动
                        performMoveDirectly(tempFileEntry, targetDirEntry, targetFilename, resolve, reject);
                    });
                }, (error) => {
                    console.log("目标文件不存在，直接移动");
                    performMoveDirectly(tempFileEntry, targetDirEntry, targetFilename, resolve, reject);
                });
                
            }, (error) => {
                console.error("目标目录获取失败:", error);
                reject(new Error("目标目录获取失败: " + error.message));
            });
            
        }, (error) => {
            console.error("临时文件获取失败:", error);
            reject(new Error("临时文件获取失败: " + error.message));
        });
    });
}

// 执行直接文件移动
function performMoveDirectly(tempFileEntry, targetDirEntry, targetFilename, resolve, reject) {
    console.log("执行直接文件移动操作");
    console.log("源文件:", tempFileEntry.name);
    console.log("目标目录:", targetDirEntry.name);
    console.log("目标文件名:", targetFilename);
    
    tempFileEntry.moveTo(targetDirEntry, targetFilename, (movedFileEntry) => {
        console.log("照片直接移动成功:", movedFileEntry.name);
        console.log("移动后文件路径:", movedFileEntry.fullPath);
        resolve(movedFileEntry);
    }, (error) => {
        console.error("照片直接移动失败:", error);
        console.error("错误代码:", error.code);
        console.error("错误消息:", error.message);
        reject(new Error("照片直接移动失败: " + error.message));
    });
} 